﻿
using UdonSharp;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using VRC.SDKBase;
using VRC.Udon;

public class ADGZ : UdonSharpBehaviour
{
    /// <summary>
    /// 长方体触发区域随机判断脚本
    /// 玩家进入触发区域后进行两次随机数生成判断
    /// </summary>
    
    [Header("触发区域设置")]
    [Tooltip("触发区域的长方体大小（米）")]
    public Vector3 triggerBoxSize = new Vector3(5f, 3f, 5f);
    
    [Tooltip("触发区域的中心偏移（相对于物体原点）")]
    public Vector3 triggerBoxCenter = Vector3.zero;
    
    [Header("可视化设置")]
    [Tooltip("是否在编辑器中显示触发区域")]
    public bool showTriggerArea = true;
    
    [Tooltip("触发区域边框颜色")]
    public Color triggerAreaColor = new Color(0f, 1f, 0f, 0.3f);
    
    [Tooltip("触发区域线框颜色")]
    public Color triggerWireColor = new Color(0f, 1f, 0f, 0.8f);
    
    [Header("随机数设置")]
    [Tooltip("第一次随机数的成功概率阈值（0-100）")]
    [Range(0, 100)]
    public int firstRandomThreshold = 50;
    
    [Tooltip("第二次随机数的成功概率阈值（0-100）")]
    [Range(0, 100)]
    public int secondRandomThreshold = 50;
    
    [Header("调试设置")]
    [Tooltip("是否显示详细的调试信息")]
    public bool enableDebugLog = true;
    
    [Header("UI文本输出设置")]
    [Tooltip("显示第一次判定结果的TextMeshPro组件 - 将场景中的TextMeshProUGUI组件拖拽到此处")]
    public TextMeshProUGUI firstStepResultText;
    
    [Tooltip("第一次判定通过时显示的自定义文字内容")]
    [TextArea(2, 4)]
    public string firstStepPassMessage = "第一次判定成功，生成判定：有";
    
    [Tooltip("第一次判定失败时显示的自定义文字内容")]
    [TextArea(2, 4)]
    public string firstStepFailMessage = "第一次判定失败，不生成爱导，流程结束";
    
    [Tooltip("显示第二次判定结果的TextMeshPro组件 - 将场景中的TextMeshProUGUI组件拖拽到此处")]
    public TextMeshProUGUI secondStepResultText;
    
    [Tooltip("第二次判定成功时显示的文字内容")]
    [TextArea(2, 4)]
    public string secondStepSuccessMessage = "落诗：再看就把你吃掉";
    
    [Tooltip("第二次判定失败时显示的文字内容")]
    [TextArea(2, 4)]
    public string secondStepFailMessage = "落诗：行注目礼吧";
    
    [Header("物体材质控制")]
    [Tooltip("需要更换材质的目标物体")]
    public GameObject targetObject;
    
    [Tooltip("第二次判定成功时使用的材质")]
    public Material successMaterial;
    
    [Tooltip("第二次判定失败时使用的材质")]
    public Material failMaterial;
    
    [Tooltip("世界生命值系统引用")]
    public WorldHealth worldHealthSystem;
    
    [Header("视野检测设置")]
    [Tooltip("视野检测的距离")]
    [Range(1f, 100f)]
    public float visionDetectionDistance = 50f;
    
    [Tooltip("视野检测的角度")]
    [Range(30f, 180f)]
    public float visionDetectionAngle = 90f;
    
    [Tooltip("视野检测的更新频率（秒）")]
    [Range(0.1f, 2f)]
    public float visionUpdateRate = 0.5f;
    
    [Tooltip("失败状态下需要物体离开视野的持续时间（秒）")]
    [Range(1f, 30f)]
    public float outOfSightDuration = 8f;

    [Header("UI显示控制")]
    [Tooltip("是否自动隐藏第一次判定结果文字")]
    public bool autoHideFirstStepText = false;
    
    [Tooltip("第一次判定结果文字的显示持续时间（秒）- 仅在自动隐藏开启时有效")]
    public float firstStepDisplayDuration = 3f;
    
    [Tooltip("是否自动隐藏第二次判定结果文字")]
    public bool autoHideSecondStepText = false;
    
    [Tooltip("第二次判定结果文字的显示持续时间（秒）- 仅在自动隐藏开启时有效")]
    public float secondStepDisplayDuration = 5f;
    
    [Tooltip("是否在开始时隐藏所有文本")]
    public bool hideTextOnStart = true;
    
    [Tooltip("新玩家进入时是否清除之前的文字显示")]
    public bool clearTextOnNewTrigger = true;
    

    
    // 内部状态
    private bool playerInTrigger = false;
    private VRCPlayerApi lastTriggeredPlayer;
    private float lastTriggerTime;
    private float triggerCooldown = 1f; // 防止重复触发的冷却时间
    
    // 材质和视野检测状态
    private bool isSecondStepSuccess = false; // 第二次判定是否成功
    private bool isObjectInSight = false; // 物体是否在视野中
    private float lastVisionCheckTime = 0f; // 上次视野检测时间
    private float outOfSightStartTime = 0f; // 物体离开视野的开始时间
    private bool isDamaging = false; // 是否正在扣血
    private Renderer targetRenderer; // 目标物体的渲染器组件
    

    
    void Start()
    {
        // 初始化时确保触发区域大小合理
        if (triggerBoxSize.x <= 0f) triggerBoxSize.x = 1f;
        if (triggerBoxSize.y <= 0f) triggerBoxSize.y = 1f;
        if (triggerBoxSize.z <= 0f) triggerBoxSize.z = 1f;
        
        // 初始化UI文本状态
        InitializeUITexts();
        
        // 确保第二次判定文字在开始时隐藏
        EnsureSecondStepTextHidden();
        
        // 初始化目标物体渲染器
        InitializeTargetObject();
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 触发区域已初始化 - 大小: {triggerBoxSize}, 中心偏移: {triggerBoxCenter}");
            Debug.Log($"[ADGZ] 第一次随机数阈值: {firstRandomThreshold}, 第二次随机数阈值: {secondRandomThreshold}");
        }
    }
    
    /// <summary>
    /// 初始化UI文本组件
    /// </summary>
    private void InitializeUITexts()
    {
        if (hideTextOnStart)
        {
            // 隐藏所有文本
            if (firstStepResultText != null)
            {
                firstStepResultText.gameObject.SetActive(false);
            }
            
            if (secondStepResultText != null)
            {
                secondStepResultText.gameObject.SetActive(false);
            }
        }
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] UI文本组件已初始化");
            Debug.Log($"[ADGZ] 第一次判定通过文字: \"{firstStepPassMessage}\"");
            Debug.Log($"[ADGZ] 第一次判定失败文字: \"{firstStepFailMessage}\"");
            Debug.Log($"[ADGZ] 第二次判定成功文字: \"{secondStepSuccessMessage}\"");
            Debug.Log($"[ADGZ] 第二次判定失败文字: \"{secondStepFailMessage}\"");
        }
    }
    
    /// <summary>
    /// 确保第二次判定文字在开始时隐藏
    /// </summary>
    private void EnsureSecondStepTextHidden()
    {
        if (secondStepResultText != null)
        {
            secondStepResultText.gameObject.SetActive(false);
            
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 确保第二次判定文字在初始化时隐藏");
            }
        }
    }
    
    /// <summary>
    /// 初始化目标物体渲染器
    /// </summary>
    private void InitializeTargetObject()
    {
        if (targetObject != null)
        {
            targetRenderer = targetObject.GetComponent<Renderer>();
            if (targetRenderer == null)
            {
                Debug.LogError($"[ADGZ] 目标物体 {targetObject.name} 没有Renderer组件!");
            }
            else if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 目标物体渲染器已初始化: {targetObject.name}");
            }
        }
        else if (enableDebugLog)
        {
            Debug.LogWarning($"[ADGZ] 未设置目标物体");
        }
    }
    
    /// <summary>
    /// 更换目标物体的材质
    /// </summary>
    private void ChangeMaterial(Material newMaterial)
    {
        if (targetRenderer != null && newMaterial != null)
        {
            targetRenderer.material = newMaterial;
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 已更换材质为: {newMaterial.name}");
            }
        }
        else if (enableDebugLog)
        {
            if (targetRenderer == null)
                Debug.LogWarning($"[ADGZ] 目标物体渲染器为空，无法更换材质");
            if (newMaterial == null)
                Debug.LogWarning($"[ADGZ] 新材质为空，无法更换");
        }
    }
    

    
    void Update()
    {
        // 检查本地玩家是否在触发区域内
        CheckPlayerInTriggerArea();
        
        // 检查物体视野状态和扣血逻辑
        UpdateVisionAndDamage();
    }
    
    /// <summary>
    /// 更新视野检测和血量扣除逻辑
    /// </summary>
    private void UpdateVisionAndDamage()
    {
        // 如果没有世界生命值系统或目标物体，直接返回
        if (worldHealthSystem == null || targetObject == null)
        {
            return;
        }
        
        // 如果玩家不在触发区域内，停止所有伤害活动并返回
        if (!playerInTrigger)
        {
            if (isDamaging)
            {
                StopAllDamageActivities();
            }
            return;
        }
        
        // 控制视野检测频率
        if (Time.time - lastVisionCheckTime < visionUpdateRate)
        {
            return;
        }
        
        lastVisionCheckTime = Time.time;
        
        // 检查物体是否在视野中
        bool wasInSight = isObjectInSight;
        isObjectInSight = IsObjectInPlayerVision();
        
        // 如果视野状态发生变化，记录时间
        if (wasInSight != isObjectInSight)
        {
            if (!isObjectInSight)
            {
                outOfSightStartTime = Time.time;
                if (enableDebugLog)
                {
                    Debug.Log($"[ADGZ] 物体离开视野，开始计时");
                }
            }
            else if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 物体进入视野");
            }
        }
        
        // 检查玩家是否还能承受伤害
        if (!worldHealthSystem.CanTakeDamage())
        {
            if (isDamaging)
            {
                isDamaging = false;
                if (enableDebugLog)
                {
                    Debug.Log($"[ADGZ] 停止扣血 - 玩家已死亡");
                }
            }
            return;
        }
        
        // 根据第二次判定结果决定扣血逻辑
        if (isSecondStepSuccess)
        {
            // 成功状态：物体在视野中时扣血
            if (isObjectInSight)
            {
                if (!isDamaging)
                {
                    isDamaging = true;
                    if (enableDebugLog)
                    {
                        Debug.Log($"[ADGZ] 开始扣血 - 成功状态下物体在视野中");
                    }
                }
                // 每次检测扣1点血
                worldHealthSystem.ContinuousDamage(1);
            }
            else
            {
                if (isDamaging)
                {
                    isDamaging = false;
                    if (enableDebugLog)
                    {
                        Debug.Log($"[ADGZ] 停止扣血 - 物体离开视野");
                    }
                }
            }
        }
        else
        {
            // 失败状态：物体离开视野持续8秒后扣血
            if (!isObjectInSight)
            {
                float outOfSightTime = Time.time - outOfSightStartTime;
                if (outOfSightTime >= outOfSightDuration)
                {
                    if (!isDamaging)
                    {
                        isDamaging = true;
                        if (enableDebugLog)
                        {
                            Debug.Log($"[ADGZ] 开始扣血 - 失败状态下物体离开视野超过{outOfSightDuration}秒");
                        }
                    }
                    // 每次检测扣1点血
                    worldHealthSystem.ContinuousDamage(1);
                }
            }
            else
            {
                if (isDamaging)
                {
                    isDamaging = false;
                    if (enableDebugLog)
                    {
                        Debug.Log($"[ADGZ] 停止扣血 - 物体重新进入视野");
                    }
                }
            }
        }
    }
    
    /// <summary>
    /// 检查目标物体是否在玩家视野中
    /// </summary>
    private bool IsObjectInPlayerVision()
    {
        VRCPlayerApi localPlayer = Networking.LocalPlayer;
        if (localPlayer == null || targetObject == null)
        {
            return false;
        }
        
        // 获取玩家头部位置和朝向
        Vector3 playerHeadPosition = localPlayer.GetTrackingData(VRCPlayerApi.TrackingDataType.Head).position;
        Vector3 playerForward = localPlayer.GetTrackingData(VRCPlayerApi.TrackingDataType.Head).rotation * Vector3.forward;
        
        // 计算玩家到物体的方向
        Vector3 directionToObject = (targetObject.transform.position - playerHeadPosition).normalized;
        
        // 检查距离
        float distanceToObject = Vector3.Distance(playerHeadPosition, targetObject.transform.position);
        if (distanceToObject > visionDetectionDistance)
        {
            return false;
        }
        
        // 检查角度
        float angle = Vector3.Angle(playerForward, directionToObject);
        if (angle > visionDetectionAngle * 0.5f)
        {
            return false;
        }
        
        // 射线检测是否有遮挡
        RaycastHit hit;
        if (Physics.Raycast(playerHeadPosition, directionToObject, out hit, distanceToObject))
        {
            // 如果射线击中的就是目标物体，说明没有遮挡
            return hit.collider.gameObject == targetObject;
        }
        
        // 如果没有击中任何物体，说明视线清晰
        return true;
    }
    
    /// <summary>
    /// 检查玩家是否在触发区域内
    /// </summary>
    private void CheckPlayerInTriggerArea()
    {
        VRCPlayerApi localPlayer = Networking.LocalPlayer;
        if (localPlayer == null)
        {
            return;
        }
        
        // 获取玩家世界坐标
        Vector3 playerPosition = localPlayer.GetPosition();
        
        // 计算触发区域的世界坐标
        Vector3 triggerCenter = transform.position + transform.TransformDirection(triggerBoxCenter);
        
        // 将玩家坐标转换到触发区域的本地坐标系
        Vector3 localPlayerPos = transform.InverseTransformPoint(playerPosition) - triggerBoxCenter;
        
        // 检查玩家是否在长方体范围内
        bool isInTrigger = Mathf.Abs(localPlayerPos.x) <= triggerBoxSize.x * 0.5f &&
                          Mathf.Abs(localPlayerPos.y) <= triggerBoxSize.y * 0.5f &&
                          Mathf.Abs(localPlayerPos.z) <= triggerBoxSize.z * 0.5f;
        
        // 玩家进入触发区域
        if (isInTrigger && !playerInTrigger)
        {
            OnPlayerEnterTrigger(localPlayer);
        }
        // 玩家离开触发区域
        else if (!isInTrigger && playerInTrigger)
        {
            OnPlayerExitTrigger(localPlayer);
        }
        
        playerInTrigger = isInTrigger;
    }
    
    /// <summary>
    /// 玩家进入触发区域时的处理
    /// </summary>
    private void OnPlayerEnterTrigger(VRCPlayerApi player)
    {
        // 检查冷却时间，防止频繁触发
        if (Time.time - lastTriggerTime < triggerCooldown)
        {
            return;
        }
        
        lastTriggeredPlayer = player;
        lastTriggerTime = Time.time;
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 玩家 {player.displayName} 进入触发区域");
        }
        
        // 如果设置了新玩家进入时清除文字，则隐藏之前的显示
        if (clearTextOnNewTrigger)
        {
            HideAllTexts();
        }
        else
        {
            // 即使不清除所有文字，也要确保第二次判定文字隐藏
            HideSecondStepText();
        }
        
        // 开始随机数判断流程
        StartRandomCheck();
    }
    
    /// <summary>
    /// 玩家离开触发区域时的处理
    /// </summary>
    private void OnPlayerExitTrigger(VRCPlayerApi player)
    {
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 玩家 {player.displayName} 离开触发区域");
        }
        
        // 玩家离开触发区域时立即停止所有伤害相关活动
        StopAllDamageActivities();
    }
    
    /// <summary>
    /// 停止所有伤害相关活动
    /// </summary>
    private void StopAllDamageActivities()
    {
        // 停止扣血
        if (isDamaging)
        {
            isDamaging = false;
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 玩家离开触发区域 - 停止扣血");
            }
        }
        

        
        // 重置视野检测相关状态
        isObjectInSight = false;
        outOfSightStartTime = 0f;
        lastVisionCheckTime = 0f;
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 所有伤害活动已停止 - 玩家离开触发区域");
        }
    }
    
    /// <summary>
    /// 开始随机数检查流程
    /// </summary>
    private void StartRandomCheck()
    {
        // 第一次随机数生成（0-100）
        int firstRandom = Random.Range(0, 101);
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第一次随机数: {firstRandom} (阈值: {firstRandomThreshold})");
        }
        
        // 第一次判断：0-50进入下一步，其他数字不进行下一步
        if (firstRandom <= firstRandomThreshold)
        {
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 第一次随机数判断通过，进入第二次判断");
            }
            
            // 显示第一次判定通过的文字
            ShowFirstStepResultText(true);
            
            // 进行第二次随机数生成
            PerformSecondRandomCheck();
        }
        else
        {
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 第一次随机数判断失败，流程结束");
            }
            
            // 第一次判定失败时的处理
            OnFirstStepFailed();
        }
    }
    
    /// <summary>
    /// 第一次判定失败时的处理
    /// </summary>
    private void OnFirstStepFailed()
    {
        // 确保第二次判定文字完全隐藏
        HideSecondStepText();
        
        // 确保第二次判定状态重置
        isSecondStepSuccess = false;
        
        // 停止所有伤害相关活动（如果有的话）
        if (isDamaging)
        {
            StopAllDamageActivities();
        }
        
        // 显示第一次判定失败的文字
        ShowFirstStepResultText(false);
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第一次判定失败处理完成 - 第二次判定文字已隐藏，状态已重置");
        }
    }
    
    /// <summary>
    /// 进行第二次随机数检查
    /// </summary>
    private void PerformSecondRandomCheck()
    {
        // 确保第二次判定文字在开始前是隐藏的
        if (secondStepResultText != null)
        {
            secondStepResultText.gameObject.SetActive(false);
        }
        
        // 第二次随机数生成（0-100）
        int secondRandom = Random.Range(0, 101);
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第二次随机数: {secondRandom} (阈值: {secondRandomThreshold})");
        }
        
        // 第二次判断：0-50输出1，否则输出2
        if (secondRandom <= secondRandomThreshold)
        {
            Debug.Log("1");
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 第二次随机数判断结果: 成功 (输出1)");
            }
            
            // 处理第二次判定成功
            OnSecondStepSuccess();
        }
        else
        {
            Debug.Log("2");
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 第二次随机数判断结果: 失败 (输出2)");
            }
            
            // 处理第二次判定失败
            OnSecondStepFailed();
        }
    }
    
    /// <summary>
    /// 第二次判定成功时的处理
    /// </summary>
    private void OnSecondStepSuccess()
    {
        // 设置第二次判定成功状态
        isSecondStepSuccess = true;
        
        // 更换材质为成功材质
        ChangeMaterial(successMaterial);
        
        // 延迟一帧显示文字，确保状态稳定
        SendCustomEventDelayedFrames(nameof(ShowSecondStepSuccessText), 1);
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第二次判定成功处理完成，即将显示成功文字");
        }
    }
    
    /// <summary>
    /// 第二次判定失败时的处理
    /// </summary>
    private void OnSecondStepFailed()
    {
        // 设置第二次判定失败状态
        isSecondStepSuccess = false;
        
        // 更换材质为失败材质
        ChangeMaterial(failMaterial);
        
        // 延迟一帧显示文字，确保状态稳定
        SendCustomEventDelayedFrames(nameof(ShowSecondStepFailText), 1);
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第二次判定失败处理完成，即将显示失败文字");
        }
    }
    
    /// <summary>
    /// 显示第二次判定成功文字（延时调用）
    /// </summary>
    public void ShowSecondStepSuccessText()
    {
        ShowSecondStepResultText(true);
    }
    
    /// <summary>
    /// 显示第二次判定失败文字（延时调用）
    /// </summary>
    public void ShowSecondStepFailText()
    {
        ShowSecondStepResultText(false);
    }
    
    /// <summary>
    /// 显示第一次判定结果的文字
    /// </summary>
    private void ShowFirstStepResultText(bool isSuccess)
    {
        if (firstStepResultText != null)
        {
            string messageToShow = isSuccess ? firstStepPassMessage : firstStepFailMessage;
            firstStepResultText.text = messageToShow;
            firstStepResultText.gameObject.SetActive(true);
            
            // 只有在自动隐藏开启时才设置定时隐藏
            if (autoHideFirstStepText)
            {
                SendCustomEventDelayedSeconds(nameof(HideFirstStepText), firstStepDisplayDuration);
            }
            
            if (enableDebugLog)
            {
                string hideInfo = autoHideFirstStepText ? $" (将在{firstStepDisplayDuration}秒后隐藏)" : " (保持显示)";
                Debug.Log($"[ADGZ] 显示第一次判定结果文字: \"{messageToShow}\"{hideInfo}");
            }
        }
    }
    
    /// <summary>
    /// 显示第二次判定结果的文字
    /// </summary>
    private void ShowSecondStepResultText(bool isSuccess)
    {
        if (secondStepResultText != null)
        {
            string messageToShow = isSuccess ? secondStepSuccessMessage : secondStepFailMessage;
            
            // 确保文字内容不为空
            if (string.IsNullOrEmpty(messageToShow))
            {
                messageToShow = isSuccess ? "第二次判定成功" : "第二次判定失败";
                if (enableDebugLog)
                {
                    Debug.LogWarning($"[ADGZ] 第二次判定文字内容为空，使用默认文字");
                }
            }
            
            // 设置文字内容
            secondStepResultText.text = messageToShow;
            
            // 强制激活GameObject
            secondStepResultText.gameObject.SetActive(true);
            
            // 只有在自动隐藏开启时才设置定时隐藏
            if (autoHideSecondStepText)
            {
                SendCustomEventDelayedSeconds(nameof(HideSecondStepText), secondStepDisplayDuration);
            }
            
            if (enableDebugLog)
            {
                string hideInfo = autoHideSecondStepText ? $" (将在{secondStepDisplayDuration}秒后隐藏)" : " (保持显示)";
                string resultType = isSuccess ? "成功" : "失败";
                Debug.Log($"[ADGZ] 第二次判定{resultType}文字已显示: \"{messageToShow}\"{hideInfo}");
                Debug.Log($"[ADGZ] GameObject状态: {secondStepResultText.gameObject.activeInHierarchy}");
            }
        }
        else if (enableDebugLog)
        {
            Debug.LogError($"[ADGZ] 第二次判定结果文字组件为空，无法显示结果");
        }
    }
    
    /// <summary>
    /// 隐藏第一次判定结果文字（延时调用）
    /// </summary>
    public void HideFirstStepText()
    {
        if (firstStepResultText != null)
        {
            firstStepResultText.gameObject.SetActive(false);
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 隐藏第一次判定结果文字");
            }
        }
    }
    
    /// <summary>
    /// 隐藏第二次判定结果文字（延时调用）
    /// </summary>
    public void HideSecondStepText()
    {
        if (secondStepResultText != null)
        {
            secondStepResultText.gameObject.SetActive(false);
            if (enableDebugLog)
            {
                Debug.Log($"[ADGZ] 隐藏第二次判定结果文字");
            }
        }
    }
    
    /// <summary>
    /// 立即隐藏所有文字
    /// </summary>
    public void HideAllTexts()
    {
        HideFirstStepText();
        HideSecondStepText();
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 隐藏所有文字");
        }
    }
    
    /// <summary>
    /// 手动触发随机检查（供调试使用）
    /// </summary>
    public void ManualTriggerRandomCheck()
    {
        VRCPlayerApi localPlayer = Networking.LocalPlayer;
        if (localPlayer != null)
        {
            Debug.Log($"[ADGZ] 手动触发随机检查");
            StartRandomCheck();
        }
    }
    
    /// <summary>
    /// 手动测试第二次判定文字显示（调试用）
    /// </summary>
    public void ManualTestSecondStepText()
    {
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 手动测试第二次判定文字显示");
        }
        
        // 测试成功文字
        ShowSecondStepResultText(true);
        
        // 3秒后测试失败文字
        SendCustomEventDelayedSeconds(nameof(TestSecondStepFailText), 3f);
    }
    
    /// <summary>
    /// 测试第二次判定失败文字（延时调用）
    /// </summary>
    public void TestSecondStepFailText()
    {
        ShowSecondStepResultText(false);
    }
    
    /// <summary>
    /// 手动设置是否自动隐藏第一次判定文字
    /// </summary>
    public void SetAutoHideFirstStep(bool autoHide)
    {
        autoHideFirstStepText = autoHide;
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第一次判定文字自动隐藏设置为: {autoHide}");
        }
    }
    
    /// <summary>
    /// 手动设置是否自动隐藏第二次判定文字
    /// </summary>
    public void SetAutoHideSecondStep(bool autoHide)
    {
        autoHideSecondStepText = autoHide;
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第二次判定文字自动隐藏设置为: {autoHide}");
        }
    }
    
    /// <summary>
    /// 切换第一次判定文字的自动隐藏状态
    /// </summary>
    public void ToggleAutoHideFirstStep()
    {
        autoHideFirstStepText = !autoHideFirstStepText;
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第一次判定文字自动隐藏切换为: {autoHideFirstStepText}");
        }
    }
    
    /// <summary>
    /// 切换第二次判定文字的自动隐藏状态
    /// </summary>
    public void ToggleAutoHideSecondStep()
    {
        autoHideSecondStepText = !autoHideSecondStepText;
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 第二次判定文字自动隐藏切换为: {autoHideSecondStepText}");
        }
    }
    
    /// <summary>
    /// 重置文本显示状态到初始状态
    /// </summary>
    public void ResetTextDisplayState()
    {
        // 隐藏所有文字
        HideAllTexts();
        
        // 取消所有延时隐藏事件
        // 注意：在UdonSharp中无法直接取消延时事件，所以我们通过状态检查来处理
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 文本显示状态已重置");
        }
    }
    
    /// <summary>
    /// 检查第一次判定文字是否正在显示
    /// </summary>
    public bool IsFirstStepTextVisible()
    {
        return firstStepResultText != null && firstStepResultText.gameObject.activeSelf;
    }
    
    /// <summary>
    /// 检查第二次判定文字是否正在显示
    /// </summary>
    public bool IsSecondStepTextVisible()
    {
        return secondStepResultText != null && secondStepResultText.gameObject.activeSelf;
    }
    
    /// <summary>
    /// 停止扣血（公共方法，可被其他脚本调用）
    /// </summary>
    public void StopDamaging()
    {
        isDamaging = false;
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 手动停止扣血");
        }
    }
    
    /// <summary>
    /// 停止所有伤害活动（公共方法，可被其他脚本调用）
    /// </summary>
    public void StopAllDamage()
    {
        StopAllDamageActivities();
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 手动停止所有伤害活动");
        }
    }
    
    /// <summary>
    /// 重置所有状态
    /// </summary>
    public void ResetAllStates()
    {
        isSecondStepSuccess = false;
        
        // 停止所有伤害活动
        StopAllDamageActivities();
        

        
        // 隐藏所有文字
        HideAllTexts();
        
        // 确保第二次判定文字完全隐藏
        HideSecondStepText();
        
        if (enableDebugLog)
        {
            Debug.Log($"[ADGZ] 所有状态已重置，包括第二次判定文字");
        }
    }
    
    /// <summary>
    /// 获取当前是否正在扣血的状态
    /// </summary>
    public bool IsDamaging()
    {
        return isDamaging;
    }
    
    /// <summary>
    /// 获取物体是否在视野中
    /// </summary>
    public bool IsObjectCurrentlyInSight()
    {
        return isObjectInSight;
    }
    
    /// <summary>
    /// 获取第二次判定是否成功
    /// </summary>
    public bool IsSecondStepSuccessful()
    {
        return isSecondStepSuccess;
    }
    
    /// <summary>
    /// 手动更换材质（调试用）
    /// </summary>
    public void ManualChangeMaterial(bool useSuccessMaterial)
    {
        Material targetMaterial = useSuccessMaterial ? successMaterial : failMaterial;
        ChangeMaterial(targetMaterial);
        if (enableDebugLog)
        {
            string materialType = useSuccessMaterial ? "成功" : "失败";
            Debug.Log($"[ADGZ] 手动更换为{materialType}材质");
        }
    }
    

    
#if UNITY_EDITOR
    /// <summary>
    /// 在编辑器中绘制触发区域可视化
    /// </summary>
    private void OnDrawGizmosSelected()
    {
        if (!showTriggerArea)
        {
            return;
        }
        
        // 设置Gizmo颜色和矩阵
        Color oldColor = Gizmos.color;
        Matrix4x4 oldMatrix = Gizmos.matrix;
        
        // 计算触发区域的世界变换矩阵
        Vector3 center = transform.position + transform.TransformDirection(triggerBoxCenter);
        Gizmos.matrix = Matrix4x4.TRS(center, transform.rotation, Vector3.one);
        
        // 绘制半透明的触发区域
        Gizmos.color = triggerAreaColor;
        Gizmos.DrawCube(Vector3.zero, triggerBoxSize);
        
        // 绘制触发区域边框
        Gizmos.color = triggerWireColor;
        Gizmos.DrawWireCube(Vector3.zero, triggerBoxSize);
        
        // 恢复原始设置
        Gizmos.color = oldColor;
        Gizmos.matrix = oldMatrix;
    }
    
    /// <summary>
    /// 在编辑器中始终显示触发区域（即使未选中）
    /// </summary>
    private void OnDrawGizmos()
    {
        if (!showTriggerArea)
        {
            return;
        }
        
        // 设置较淡的颜色，用于未选中状态
        Color oldColor = Gizmos.color;
        Matrix4x4 oldMatrix = Gizmos.matrix;
        
        Vector3 center = transform.position + transform.TransformDirection(triggerBoxCenter);
        Gizmos.matrix = Matrix4x4.TRS(center, transform.rotation, Vector3.one);
        
        // 绘制较淡的线框
        Color fadeColor = triggerWireColor;
        fadeColor.a *= 0.3f;
        Gizmos.color = fadeColor;
        Gizmos.DrawWireCube(Vector3.zero, triggerBoxSize);
        
        Gizmos.color = oldColor;
        Gizmos.matrix = oldMatrix;
    }
#endif
}
